Home | History | Annotate | Download | only in message_center 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "ui/message_center/message_center_impl.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/message_loop/message_loop.h"
      9 #include "base/run_loop.h"
     10 #include "base/strings/utf_string_conversions.h"
     11 #include "testing/gtest/include/gtest/gtest.h"
     12 #include "ui/gfx/canvas.h"
     13 #include "ui/gfx/size.h"
     14 #include "ui/message_center/message_center.h"
     15 #include "ui/message_center/message_center_types.h"
     16 #include "ui/message_center/notification_blocker.h"
     17 #include "ui/message_center/notification_types.h"
     18 #include "ui/message_center/notifier_settings.h"
     19 
     20 using base::UTF8ToUTF16;
     21 
     22 namespace message_center {
     23 namespace {
     24 
     25 class MessageCenterImplTest : public testing::Test,
     26                               public MessageCenterObserver {
     27  public:
     28   MessageCenterImplTest() {}
     29 
     30   virtual void SetUp() OVERRIDE {
     31     MessageCenter::Initialize();
     32     message_center_ = MessageCenter::Get();
     33     loop_.reset(new base::MessageLoop);
     34     run_loop_.reset(new base::RunLoop());
     35     closure_ = run_loop_->QuitClosure();
     36   }
     37 
     38   virtual void TearDown() OVERRIDE {
     39     run_loop_.reset();
     40     loop_.reset();
     41     message_center_ = NULL;
     42     MessageCenter::Shutdown();
     43   }
     44 
     45   MessageCenter* message_center() const { return message_center_; }
     46   NotifierSettingsObserver* notifier_settings_observer() const {
     47     return static_cast<NotifierSettingsObserver*>(message_center_impl());
     48   }
     49   MessageCenterImpl* message_center_impl() const {
     50     return reinterpret_cast<MessageCenterImpl*>(message_center_);
     51   }
     52 
     53   base::RunLoop* run_loop() const { return run_loop_.get(); }
     54   base::Closure closure() const { return closure_; }
     55 
     56  protected:
     57   Notification* CreateSimpleNotification(const std::string& id) {
     58     return CreateNotificationWithNotifierId(
     59         id,
     60         "app1",
     61         NOTIFICATION_TYPE_SIMPLE);
     62   }
     63 
     64   Notification* CreateSimpleNotificationWithNotifierId(
     65     const std::string& id, const std::string& notifier_id) {
     66     return CreateNotificationWithNotifierId(
     67         id,
     68         notifier_id,
     69         NOTIFICATION_TYPE_SIMPLE);
     70   }
     71 
     72   Notification* CreateNotification(const std::string& id,
     73                                    message_center::NotificationType type) {
     74     return CreateNotificationWithNotifierId(id, "app1", type);
     75   }
     76 
     77   Notification* CreateNotificationWithNotifierId(
     78       const std::string& id,
     79       const std::string& notifier_id,
     80       message_center::NotificationType type) {
     81     RichNotificationData optional_fields;
     82     optional_fields.buttons.push_back(ButtonInfo(UTF8ToUTF16("foo")));
     83     optional_fields.buttons.push_back(ButtonInfo(UTF8ToUTF16("foo")));
     84     return new Notification(type,
     85                             id,
     86                             UTF8ToUTF16("title"),
     87                             UTF8ToUTF16(id),
     88                             gfx::Image() /* icon */,
     89                             base::string16() /* display_source */,
     90                             NotifierId(NotifierId::APPLICATION, notifier_id),
     91                             optional_fields,
     92                             NULL);
     93   }
     94 
     95 
     96  private:
     97   MessageCenter* message_center_;
     98   scoped_ptr<base::MessageLoop> loop_;
     99   scoped_ptr<base::RunLoop> run_loop_;
    100   base::Closure closure_;
    101 
    102   DISALLOW_COPY_AND_ASSIGN(MessageCenterImplTest);
    103 };
    104 
    105 class ToggledNotificationBlocker : public NotificationBlocker {
    106  public:
    107   explicit ToggledNotificationBlocker(MessageCenter* message_center)
    108       : NotificationBlocker(message_center),
    109         notifications_enabled_(true) {}
    110   virtual ~ToggledNotificationBlocker() {}
    111 
    112   void SetNotificationsEnabled(bool enabled) {
    113     if (notifications_enabled_ != enabled) {
    114       notifications_enabled_ = enabled;
    115       NotifyBlockingStateChanged();
    116     }
    117   }
    118 
    119   // NotificationBlocker overrides:
    120   virtual  bool ShouldShowNotificationAsPopup(
    121       const message_center::NotifierId& notifier_id) const OVERRIDE {
    122     return notifications_enabled_;
    123   }
    124 
    125  private:
    126   bool notifications_enabled_;
    127 
    128   DISALLOW_COPY_AND_ASSIGN(ToggledNotificationBlocker);
    129 };
    130 
    131 class PopupNotificationBlocker : public ToggledNotificationBlocker {
    132  public:
    133   PopupNotificationBlocker(MessageCenter* message_center,
    134                            const NotifierId& allowed_notifier)
    135       : ToggledNotificationBlocker(message_center),
    136         allowed_notifier_(allowed_notifier) {}
    137   virtual ~PopupNotificationBlocker() {}
    138 
    139   // NotificationBlocker overrides:
    140   virtual bool ShouldShowNotificationAsPopup(
    141       const NotifierId& notifier_id) const OVERRIDE {
    142     return (notifier_id == allowed_notifier_) ||
    143         ToggledNotificationBlocker::ShouldShowNotificationAsPopup(notifier_id);
    144   }
    145 
    146  private:
    147   NotifierId allowed_notifier_;
    148 
    149   DISALLOW_COPY_AND_ASSIGN(PopupNotificationBlocker);
    150 };
    151 
    152 class TotalNotificationBlocker : public PopupNotificationBlocker {
    153  public:
    154   TotalNotificationBlocker(MessageCenter* message_center,
    155                            const NotifierId& allowed_notifier)
    156       : PopupNotificationBlocker(message_center, allowed_notifier) {}
    157   virtual ~TotalNotificationBlocker() {}
    158 
    159   // NotificationBlocker overrides:
    160   virtual bool ShouldShowNotification(
    161       const NotifierId& notifier_id) const OVERRIDE {
    162     return ShouldShowNotificationAsPopup(notifier_id);
    163   }
    164 
    165  private:
    166   DISALLOW_COPY_AND_ASSIGN(TotalNotificationBlocker);
    167 };
    168 
    169 bool PopupNotificationsContain(
    170     const NotificationList::PopupNotifications& popups,
    171     const std::string& id) {
    172   for (NotificationList::PopupNotifications::const_iterator iter =
    173            popups.begin(); iter != popups.end(); ++iter) {
    174     if ((*iter)->id() == id)
    175       return true;
    176   }
    177   return false;
    178 }
    179 
    180 // Right now, MessageCenter::HasNotification() returns regardless of blockers.
    181 bool NotificationsContain(
    182     const NotificationList::Notifications& notifications,
    183     const std::string& id) {
    184   for (NotificationList::Notifications::const_iterator iter =
    185            notifications.begin(); iter != notifications.end(); ++iter) {
    186     if ((*iter)->id() == id)
    187       return true;
    188   }
    189   return false;
    190 }
    191 
    192 }  // namespace
    193 
    194 namespace internal {
    195 
    196 class MockPopupTimersController : public PopupTimersController {
    197  public:
    198   MockPopupTimersController(MessageCenter* message_center,
    199                             base::Closure quit_closure)
    200       : PopupTimersController(message_center),
    201         timer_finished_(false),
    202         quit_closure_(quit_closure) {}
    203   virtual ~MockPopupTimersController() {}
    204 
    205   virtual void TimerFinished(const std::string& id) OVERRIDE {
    206     base::MessageLoop::current()->PostTask(FROM_HERE, quit_closure_);
    207     timer_finished_ = true;
    208     last_id_ = id;
    209   }
    210 
    211   bool timer_finished() const { return timer_finished_; }
    212   const std::string& last_id() const { return last_id_; }
    213 
    214  private:
    215   bool timer_finished_;
    216   std::string last_id_;
    217   base::Closure quit_closure_;
    218 };
    219 
    220 TEST_F(MessageCenterImplTest, PopupTimersEmptyController) {
    221   scoped_ptr<PopupTimersController> popup_timers_controller =
    222       make_scoped_ptr(new PopupTimersController(message_center()));
    223 
    224   // Test that all functions succed without any timers created.
    225   popup_timers_controller->PauseAll();
    226   popup_timers_controller->StartAll();
    227   popup_timers_controller->CancelAll();
    228   popup_timers_controller->TimerFinished("unknown");
    229   popup_timers_controller->PauseTimer("unknown");
    230   popup_timers_controller->CancelTimer("unknown");
    231 }
    232 
    233 TEST_F(MessageCenterImplTest, PopupTimersControllerStartTimer) {
    234   scoped_ptr<MockPopupTimersController> popup_timers_controller =
    235       make_scoped_ptr(
    236           new MockPopupTimersController(message_center(), closure()));
    237   popup_timers_controller->StartTimer("test",
    238                                       base::TimeDelta::FromMilliseconds(1));
    239   run_loop()->Run();
    240   EXPECT_TRUE(popup_timers_controller->timer_finished());
    241 }
    242 
    243 TEST_F(MessageCenterImplTest, PopupTimersControllerPauseTimer) {
    244   scoped_ptr<MockPopupTimersController> popup_timers_controller =
    245       make_scoped_ptr(
    246           new MockPopupTimersController(message_center(), closure()));
    247   popup_timers_controller->StartTimer("test",
    248                                       base::TimeDelta::FromMilliseconds(1));
    249   popup_timers_controller->PauseTimer("test");
    250   run_loop()->RunUntilIdle();
    251 
    252   EXPECT_FALSE(popup_timers_controller->timer_finished());
    253 }
    254 
    255 TEST_F(MessageCenterImplTest, PopupTimersControllerCancelTimer) {
    256   scoped_ptr<MockPopupTimersController> popup_timers_controller =
    257       make_scoped_ptr(
    258           new MockPopupTimersController(message_center(), closure()));
    259   popup_timers_controller->StartTimer("test",
    260                                       base::TimeDelta::FromMilliseconds(1));
    261   popup_timers_controller->CancelTimer("test");
    262   run_loop()->RunUntilIdle();
    263 
    264   EXPECT_FALSE(popup_timers_controller->timer_finished());
    265 }
    266 
    267 TEST_F(MessageCenterImplTest, PopupTimersControllerPauseAllTimers) {
    268   scoped_ptr<MockPopupTimersController> popup_timers_controller =
    269       make_scoped_ptr(
    270           new MockPopupTimersController(message_center(), closure()));
    271   popup_timers_controller->StartTimer("test",
    272                                       base::TimeDelta::FromMilliseconds(1));
    273   popup_timers_controller->PauseAll();
    274   run_loop()->RunUntilIdle();
    275 
    276   EXPECT_FALSE(popup_timers_controller->timer_finished());
    277 }
    278 
    279 TEST_F(MessageCenterImplTest, PopupTimersControllerStartAllTimers) {
    280   scoped_ptr<MockPopupTimersController> popup_timers_controller =
    281       make_scoped_ptr(
    282           new MockPopupTimersController(message_center(), closure()));
    283   popup_timers_controller->StartTimer("test",
    284                                       base::TimeDelta::FromMilliseconds(1));
    285   popup_timers_controller->PauseAll();
    286   popup_timers_controller->StartAll();
    287   run_loop()->Run();
    288 
    289   EXPECT_TRUE(popup_timers_controller->timer_finished());
    290 }
    291 
    292 TEST_F(MessageCenterImplTest, PopupTimersControllerStartMultipleTimers) {
    293   scoped_ptr<MockPopupTimersController> popup_timers_controller =
    294       make_scoped_ptr(
    295           new MockPopupTimersController(message_center(), closure()));
    296   popup_timers_controller->StartTimer("test",
    297                                       base::TimeDelta::FromMilliseconds(5));
    298   popup_timers_controller->StartTimer("test2",
    299                                       base::TimeDelta::FromMilliseconds(1));
    300   popup_timers_controller->StartTimer("test3",
    301                                       base::TimeDelta::FromMilliseconds(3));
    302   popup_timers_controller->PauseAll();
    303   popup_timers_controller->StartAll();
    304   run_loop()->Run();
    305 
    306   EXPECT_EQ(popup_timers_controller->last_id(), "test2");
    307   EXPECT_TRUE(popup_timers_controller->timer_finished());
    308 }
    309 
    310 TEST_F(MessageCenterImplTest, PopupTimersControllerStartMultipleTimersPause) {
    311   scoped_ptr<MockPopupTimersController> popup_timers_controller =
    312       make_scoped_ptr(
    313           new MockPopupTimersController(message_center(), closure()));
    314   popup_timers_controller->StartTimer("test",
    315                                       base::TimeDelta::FromMilliseconds(5));
    316   popup_timers_controller->StartTimer("test2",
    317                                       base::TimeDelta::FromMilliseconds(1));
    318   popup_timers_controller->StartTimer("test3",
    319                                       base::TimeDelta::FromMilliseconds(3));
    320   popup_timers_controller->PauseTimer("test2");
    321 
    322   run_loop()->Run();
    323 
    324   EXPECT_EQ(popup_timers_controller->last_id(), "test3");
    325   EXPECT_TRUE(popup_timers_controller->timer_finished());
    326 }
    327 
    328 TEST_F(MessageCenterImplTest, PopupTimersControllerResetTimer) {
    329   scoped_ptr<MockPopupTimersController> popup_timers_controller =
    330       make_scoped_ptr(
    331           new MockPopupTimersController(message_center(), closure()));
    332   popup_timers_controller->StartTimer("test",
    333                                       base::TimeDelta::FromMilliseconds(5));
    334   popup_timers_controller->StartTimer("test2",
    335                                       base::TimeDelta::FromMilliseconds(1));
    336   popup_timers_controller->StartTimer("test3",
    337                                       base::TimeDelta::FromMilliseconds(3));
    338   popup_timers_controller->PauseTimer("test2");
    339   popup_timers_controller->ResetTimer("test",
    340                                       base::TimeDelta::FromMilliseconds(2));
    341 
    342   run_loop()->Run();
    343 
    344   EXPECT_EQ(popup_timers_controller->last_id(), "test");
    345   EXPECT_TRUE(popup_timers_controller->timer_finished());
    346 }
    347 
    348 TEST_F(MessageCenterImplTest, NotificationBlocker) {
    349   NotifierId notifier_id(NotifierId::APPLICATION, "app1");
    350   // Multiple blockers to verify the case that one blocker blocks but another
    351   // doesn't.
    352   ToggledNotificationBlocker blocker1(message_center());
    353   ToggledNotificationBlocker blocker2(message_center());
    354 
    355   message_center()->AddNotification(scoped_ptr<Notification>(new Notification(
    356       NOTIFICATION_TYPE_SIMPLE,
    357       "id1",
    358       UTF8ToUTF16("title"),
    359       UTF8ToUTF16("message"),
    360       gfx::Image() /* icon */,
    361       base::string16() /* display_source */,
    362       notifier_id,
    363       RichNotificationData(),
    364       NULL)));
    365   message_center()->AddNotification(scoped_ptr<Notification>(new Notification(
    366       NOTIFICATION_TYPE_SIMPLE,
    367       "id2",
    368       UTF8ToUTF16("title"),
    369       UTF8ToUTF16("message"),
    370       gfx::Image() /* icon */,
    371       base::string16() /* display_source */,
    372       notifier_id,
    373       RichNotificationData(),
    374       NULL)));
    375   EXPECT_EQ(2u, message_center()->GetPopupNotifications().size());
    376   EXPECT_EQ(2u, message_center()->GetVisibleNotifications().size());
    377 
    378   // Block all notifications. All popups are gone and message center should be
    379   // hidden.
    380   blocker1.SetNotificationsEnabled(false);
    381   EXPECT_TRUE(message_center()->GetPopupNotifications().empty());
    382   EXPECT_EQ(2u, message_center()->GetVisibleNotifications().size());
    383 
    384   // Updates |blocker2| state, which doesn't affect the global state.
    385   blocker2.SetNotificationsEnabled(false);
    386   EXPECT_TRUE(message_center()->GetPopupNotifications().empty());
    387   EXPECT_EQ(2u, message_center()->GetVisibleNotifications().size());
    388 
    389   blocker2.SetNotificationsEnabled(true);
    390   EXPECT_TRUE(message_center()->GetPopupNotifications().empty());
    391   EXPECT_EQ(2u, message_center()->GetVisibleNotifications().size());
    392 
    393   // If |blocker2| blocks, then unblocking blocker1 doesn't change the global
    394   // state.
    395   blocker2.SetNotificationsEnabled(false);
    396   blocker1.SetNotificationsEnabled(true);
    397   EXPECT_TRUE(message_center()->GetPopupNotifications().empty());
    398   EXPECT_EQ(2u, message_center()->GetVisibleNotifications().size());
    399 
    400   // Unblock both blockers, which recovers the global state, but the popups
    401   // aren't shown.
    402   blocker2.SetNotificationsEnabled(true);
    403   EXPECT_TRUE(message_center()->GetPopupNotifications().empty());
    404   EXPECT_EQ(2u, message_center()->GetVisibleNotifications().size());
    405 }
    406 
    407 TEST_F(MessageCenterImplTest, NotificationsDuringBlocked) {
    408   NotifierId notifier_id(NotifierId::APPLICATION, "app1");
    409   ToggledNotificationBlocker blocker(message_center());
    410 
    411   message_center()->AddNotification(scoped_ptr<Notification>(new Notification(
    412       NOTIFICATION_TYPE_SIMPLE,
    413       "id1",
    414       UTF8ToUTF16("title"),
    415       UTF8ToUTF16("message"),
    416       gfx::Image() /* icon */,
    417       base::string16() /* display_source */,
    418       notifier_id,
    419       RichNotificationData(),
    420       NULL)));
    421   EXPECT_EQ(1u, message_center()->GetPopupNotifications().size());
    422   EXPECT_EQ(1u, message_center()->GetVisibleNotifications().size());
    423 
    424   // Create a notification during blocked. Still no popups.
    425   blocker.SetNotificationsEnabled(false);
    426   message_center()->AddNotification(scoped_ptr<Notification>(new Notification(
    427       NOTIFICATION_TYPE_SIMPLE,
    428       "id2",
    429       UTF8ToUTF16("title"),
    430       UTF8ToUTF16("message"),
    431       gfx::Image() /* icon */,
    432       base::string16() /* display_source */,
    433       notifier_id,
    434       RichNotificationData(),
    435       NULL)));
    436   EXPECT_TRUE(message_center()->GetPopupNotifications().empty());
    437   EXPECT_EQ(2u, message_center()->GetVisibleNotifications().size());
    438 
    439   // Unblock notifications, the id1 should appear as a popup.
    440   blocker.SetNotificationsEnabled(true);
    441   NotificationList::PopupNotifications popups =
    442       message_center()->GetPopupNotifications();
    443   EXPECT_EQ(1u, popups.size());
    444   EXPECT_TRUE(PopupNotificationsContain(popups, "id2"));
    445   EXPECT_EQ(2u, message_center()->GetVisibleNotifications().size());
    446 }
    447 
    448 // Similar to other blocker cases but this test case allows |notifier_id2| even
    449 // in blocked.
    450 TEST_F(MessageCenterImplTest, NotificationBlockerAllowsPopups) {
    451   NotifierId notifier_id1(NotifierId::APPLICATION, "app1");
    452   NotifierId notifier_id2(NotifierId::APPLICATION, "app2");
    453   PopupNotificationBlocker blocker(message_center(), notifier_id2);
    454 
    455   message_center()->AddNotification(scoped_ptr<Notification>(new Notification(
    456       NOTIFICATION_TYPE_SIMPLE,
    457       "id1",
    458       UTF8ToUTF16("title"),
    459       UTF8ToUTF16("message"),
    460       gfx::Image() /* icon */,
    461       base::string16() /* display_source */,
    462       notifier_id1,
    463       RichNotificationData(),
    464       NULL)));
    465   message_center()->AddNotification(scoped_ptr<Notification>(new Notification(
    466       NOTIFICATION_TYPE_SIMPLE,
    467       "id2",
    468       UTF8ToUTF16("title"),
    469       UTF8ToUTF16("message"),
    470       gfx::Image() /* icon */,
    471       base::string16() /* display_source */,
    472       notifier_id2,
    473       RichNotificationData(),
    474       NULL)));
    475 
    476   // "id1" is closed but "id2" is still visible as a popup.
    477   blocker.SetNotificationsEnabled(false);
    478   NotificationList::PopupNotifications popups =
    479       message_center()->GetPopupNotifications();
    480   EXPECT_EQ(1u, popups.size());
    481   EXPECT_TRUE(PopupNotificationsContain(popups, "id2"));
    482   EXPECT_EQ(2u, message_center()->GetVisibleNotifications().size());
    483 
    484   message_center()->AddNotification(scoped_ptr<Notification>(new Notification(
    485       NOTIFICATION_TYPE_SIMPLE,
    486       "id3",
    487       UTF8ToUTF16("title"),
    488       UTF8ToUTF16("message"),
    489       gfx::Image() /* icon */,
    490       base::string16() /* display_source */,
    491       notifier_id1,
    492       RichNotificationData(),
    493       NULL)));
    494   message_center()->AddNotification(scoped_ptr<Notification>(new Notification(
    495       NOTIFICATION_TYPE_SIMPLE,
    496       "id4",
    497       UTF8ToUTF16("title"),
    498       UTF8ToUTF16("message"),
    499       gfx::Image() /* icon */,
    500       base::string16() /* display_source */,
    501       notifier_id2,
    502       RichNotificationData(),
    503       NULL)));
    504   popups = message_center()->GetPopupNotifications();
    505   EXPECT_EQ(2u, popups.size());
    506   EXPECT_TRUE(PopupNotificationsContain(popups, "id2"));
    507   EXPECT_TRUE(PopupNotificationsContain(popups, "id4"));
    508   EXPECT_EQ(4u, message_center()->GetVisibleNotifications().size());
    509 
    510   blocker.SetNotificationsEnabled(true);
    511   popups = message_center()->GetPopupNotifications();
    512   EXPECT_EQ(3u, popups.size());
    513   EXPECT_TRUE(PopupNotificationsContain(popups, "id2"));
    514   EXPECT_TRUE(PopupNotificationsContain(popups, "id3"));
    515   EXPECT_TRUE(PopupNotificationsContain(popups, "id4"));
    516   EXPECT_EQ(4u, message_center()->GetVisibleNotifications().size());
    517 }
    518 
    519 // TotalNotificationBlocker suppresses showing notifications even from the list.
    520 // This would provide the feature to 'separated' message centers per-profile for
    521 // ChromeOS multi-login.
    522 TEST_F(MessageCenterImplTest, TotalNotificationBlocker) {
    523   NotifierId notifier_id1(NotifierId::APPLICATION, "app1");
    524   NotifierId notifier_id2(NotifierId::APPLICATION, "app2");
    525   TotalNotificationBlocker blocker(message_center(), notifier_id2);
    526 
    527   message_center()->AddNotification(scoped_ptr<Notification>(new Notification(
    528       NOTIFICATION_TYPE_SIMPLE,
    529       "id1",
    530       UTF8ToUTF16("title"),
    531       UTF8ToUTF16("message"),
    532       gfx::Image() /* icon */,
    533       base::string16() /* display_source */,
    534       notifier_id1,
    535       RichNotificationData(),
    536       NULL)));
    537   message_center()->AddNotification(scoped_ptr<Notification>(new Notification(
    538       NOTIFICATION_TYPE_SIMPLE,
    539       "id2",
    540       UTF8ToUTF16("title"),
    541       UTF8ToUTF16("message"),
    542       gfx::Image() /* icon */,
    543       base::string16() /* display_source */,
    544       notifier_id2,
    545       RichNotificationData(),
    546       NULL)));
    547 
    548   // "id1" becomes invisible while "id2" is still visible.
    549   blocker.SetNotificationsEnabled(false);
    550   EXPECT_EQ(1u, message_center()->NotificationCount());
    551   NotificationList::Notifications notifications =
    552       message_center()->GetVisibleNotifications();
    553   EXPECT_FALSE(NotificationsContain(notifications, "id1"));
    554   EXPECT_TRUE(NotificationsContain(notifications, "id2"));
    555 
    556   message_center()->AddNotification(scoped_ptr<Notification>(new Notification(
    557       NOTIFICATION_TYPE_SIMPLE,
    558       "id3",
    559       UTF8ToUTF16("title"),
    560       UTF8ToUTF16("message"),
    561       gfx::Image() /* icon */,
    562       base::string16() /* display_source */,
    563       notifier_id1,
    564       RichNotificationData(),
    565       NULL)));
    566   message_center()->AddNotification(scoped_ptr<Notification>(new Notification(
    567       NOTIFICATION_TYPE_SIMPLE,
    568       "id4",
    569       UTF8ToUTF16("title"),
    570       UTF8ToUTF16("message"),
    571       gfx::Image() /* icon */,
    572       base::string16() /* display_source */,
    573       notifier_id2,
    574       RichNotificationData(),
    575       NULL)));
    576   EXPECT_EQ(2u, message_center()->NotificationCount());
    577   notifications = message_center()->GetVisibleNotifications();
    578   EXPECT_FALSE(NotificationsContain(notifications, "id1"));
    579   EXPECT_TRUE(NotificationsContain(notifications, "id2"));
    580   EXPECT_FALSE(NotificationsContain(notifications, "id3"));
    581   EXPECT_TRUE(NotificationsContain(notifications, "id4"));
    582 
    583   blocker.SetNotificationsEnabled(true);
    584   EXPECT_EQ(4u, message_center()->NotificationCount());
    585   notifications = message_center()->GetVisibleNotifications();
    586   EXPECT_TRUE(NotificationsContain(notifications, "id1"));
    587   EXPECT_TRUE(NotificationsContain(notifications, "id2"));
    588   EXPECT_TRUE(NotificationsContain(notifications, "id3"));
    589   EXPECT_TRUE(NotificationsContain(notifications, "id4"));
    590 
    591   // RemoveAllVisibleNotifications should remove just visible notifications.
    592   blocker.SetNotificationsEnabled(false);
    593   message_center()->RemoveAllVisibleNotifications(false /* by_user */);
    594   EXPECT_EQ(0u, message_center()->NotificationCount());
    595   blocker.SetNotificationsEnabled(true);
    596   EXPECT_EQ(2u, message_center()->NotificationCount());
    597   notifications = message_center()->GetVisibleNotifications();
    598   EXPECT_TRUE(NotificationsContain(notifications, "id1"));
    599   EXPECT_FALSE(NotificationsContain(notifications, "id2"));
    600   EXPECT_TRUE(NotificationsContain(notifications, "id3"));
    601   EXPECT_FALSE(NotificationsContain(notifications, "id4"));
    602 
    603   // And RemoveAllNotifications should remove all.
    604   blocker.SetNotificationsEnabled(false);
    605   message_center()->RemoveAllNotifications(false /* by_user */);
    606   EXPECT_EQ(0u, message_center()->NotificationCount());
    607 }
    608 
    609 TEST_F(MessageCenterImplTest, QueueUpdatesWithCenterVisible) {
    610   std::string id("id1");
    611   std::string id2("id2");
    612   NotifierId notifier_id1(NotifierId::APPLICATION, "app1");
    613 
    614   // First, add and update a notification to ensure updates happen
    615   // normally.
    616   scoped_ptr<Notification> notification(CreateSimpleNotification(id));
    617   message_center()->AddNotification(notification.Pass());
    618   notification.reset(CreateSimpleNotification(id2));
    619   message_center()->UpdateNotification(id, notification.Pass());
    620   EXPECT_TRUE(message_center()->FindVisibleNotificationById(id2));
    621   EXPECT_FALSE(message_center()->FindVisibleNotificationById(id));
    622 
    623   // Then open the message center.
    624   message_center()->SetVisibility(VISIBILITY_MESSAGE_CENTER);
    625 
    626   // Then update a notification; nothing should have happened.
    627   notification.reset(CreateSimpleNotification(id));
    628   message_center()->UpdateNotification(id2, notification.Pass());
    629   EXPECT_TRUE(message_center()->FindVisibleNotificationById(id2));
    630   EXPECT_FALSE(message_center()->FindVisibleNotificationById(id));
    631 
    632   // Close the message center; then the update should have propagated.
    633   message_center()->SetVisibility(VISIBILITY_TRANSIENT);
    634   EXPECT_FALSE(message_center()->FindVisibleNotificationById(id2));
    635   EXPECT_TRUE(message_center()->FindVisibleNotificationById(id));
    636 }
    637 
    638 TEST_F(MessageCenterImplTest, ComplexQueueing) {
    639   std::string ids[5] = {"0", "1", "2", "3", "4p"};
    640   NotifierId notifier_id1(NotifierId::APPLICATION, "app1");
    641 
    642   scoped_ptr<Notification> notification;
    643   // Add some notifications
    644   int i = 0;
    645   for (; i < 3; i++) {
    646     notification.reset(CreateSimpleNotification(ids[i]));
    647     message_center()->AddNotification(notification.Pass());
    648   }
    649   for (i = 0; i < 3; i++) {
    650     EXPECT_TRUE(message_center()->FindVisibleNotificationById(ids[i]));
    651   }
    652   for (; i < 5; i++) {
    653     EXPECT_FALSE(message_center()->FindVisibleNotificationById(ids[i]));
    654   }
    655 
    656   notification.reset(CreateNotification(ids[4], NOTIFICATION_TYPE_PROGRESS));
    657   message_center()->AddNotification(notification.Pass());
    658 
    659   // Now start queueing.
    660   // NL: ["0", "1", "2", "4p"]
    661   message_center()->SetVisibility(VISIBILITY_MESSAGE_CENTER);
    662 
    663   // This should update notification "1" to have id "3".
    664   notification.reset(CreateSimpleNotification(ids[3]));
    665   message_center()->UpdateNotification(ids[1], notification.Pass());
    666 
    667   notification.reset(CreateSimpleNotification(ids[4]));
    668   message_center()->UpdateNotification(ids[4], notification.Pass());
    669 
    670   notification.reset(CreateNotification(ids[4], NOTIFICATION_TYPE_PROGRESS));
    671   message_center()->UpdateNotification(ids[4], notification.Pass());
    672 
    673   // This should update notification "3" to a new ID after we go TRANSIENT.
    674   notification.reset(CreateSimpleNotification("New id"));
    675   message_center()->UpdateNotification(ids[3], notification.Pass());
    676 
    677   // This should create a new "3", that doesn't overwrite the update to 3
    678   // before.
    679   notification.reset(CreateSimpleNotification(ids[3]));
    680   message_center()->AddNotification(notification.Pass());
    681 
    682   // The NL should still be the same: ["0", "1", "2", "4p"]
    683   EXPECT_TRUE(message_center()->FindVisibleNotificationById(ids[0]));
    684   EXPECT_TRUE(message_center()->FindVisibleNotificationById(ids[1]));
    685   EXPECT_TRUE(message_center()->FindVisibleNotificationById(ids[2]));
    686   EXPECT_FALSE(message_center()->FindVisibleNotificationById(ids[3]));
    687   EXPECT_TRUE(message_center()->FindVisibleNotificationById(ids[4]));
    688   EXPECT_EQ(message_center()->GetVisibleNotifications().size(), 4u);
    689   message_center()->SetVisibility(VISIBILITY_TRANSIENT);
    690 
    691   EXPECT_TRUE(message_center()->FindVisibleNotificationById(ids[0]));
    692   EXPECT_FALSE(message_center()->FindVisibleNotificationById(ids[1]));
    693   EXPECT_TRUE(message_center()->FindVisibleNotificationById(ids[2]));
    694   EXPECT_TRUE(message_center()->FindVisibleNotificationById(ids[3]));
    695   EXPECT_TRUE(message_center()->FindVisibleNotificationById(ids[4]));
    696   EXPECT_TRUE(message_center()->FindVisibleNotificationById("New id"));
    697   EXPECT_EQ(message_center()->GetVisibleNotifications().size(), 5u);
    698 }
    699 
    700 TEST_F(MessageCenterImplTest, QueuedDirectUpdates) {
    701   std::string id("id1");
    702   std::string id2("id2");
    703   NotifierId notifier_id1(NotifierId::APPLICATION, "app1");
    704 
    705   gfx::Size original_size(0, 0);
    706   // Open the message center to prevent adding notifications
    707   message_center()->SetVisibility(VISIBILITY_MESSAGE_CENTER);
    708 
    709   // Create new notification to be added to the queue; images all have the same
    710   // original size.
    711   scoped_ptr<Notification> notification(CreateSimpleNotification(id));
    712 
    713   // Double-check that sizes all match.
    714   const std::vector<ButtonInfo>& original_buttons = notification->buttons();
    715   ASSERT_EQ(2u, original_buttons.size());
    716 
    717   EXPECT_EQ(original_size, notification->icon().Size());
    718   EXPECT_EQ(original_size, notification->image().Size());
    719   EXPECT_EQ(original_size, original_buttons[0].icon.Size());
    720   EXPECT_EQ(original_size, original_buttons[1].icon.Size());
    721 
    722   message_center()->AddNotification(notification.Pass());
    723 
    724   // The notification should be in the queue.
    725   EXPECT_FALSE(message_center()->FindVisibleNotificationById(id));
    726 
    727   // Now try setting the icon to a different size.
    728   gfx::Size new_size(16, 16);
    729   EXPECT_NE(original_size, new_size);
    730 
    731   gfx::Canvas canvas(new_size, 1.0f, true);
    732   canvas.DrawColor(SK_ColorBLUE);
    733   gfx::Image testImage(gfx::Image(gfx::ImageSkia(canvas.ExtractImageRep())));
    734   message_center()->SetNotificationIcon(id, testImage);
    735   message_center()->SetNotificationImage(id, testImage);
    736   message_center()->SetNotificationButtonIcon(id, 0, testImage);
    737   message_center()->SetNotificationButtonIcon(id, 1, testImage);
    738 
    739   // The notification should be in the queue.
    740   EXPECT_FALSE(message_center()->FindVisibleNotificationById(id));
    741 
    742   // Close the message center; then the update should have propagated.
    743   message_center()->SetVisibility(VISIBILITY_TRANSIENT);
    744   // The notification should no longer be in the queue.
    745   EXPECT_TRUE(message_center()->FindVisibleNotificationById(id));
    746 
    747   Notification* mc_notification =
    748       *(message_center()->GetVisibleNotifications().begin());
    749   const std::vector<ButtonInfo>& buttons = mc_notification->buttons();
    750   ASSERT_EQ(2u, buttons.size());
    751 
    752   EXPECT_EQ(new_size, mc_notification->icon().Size());
    753   EXPECT_EQ(new_size, mc_notification->image().Size());
    754   EXPECT_EQ(new_size, buttons[0].icon.Size());
    755   EXPECT_EQ(new_size, buttons[1].icon.Size());
    756 }
    757 
    758 TEST_F(MessageCenterImplTest, CachedUnreadCount) {
    759   message_center()->AddNotification(
    760       scoped_ptr<Notification>(CreateSimpleNotification("id1")));
    761   message_center()->AddNotification(
    762       scoped_ptr<Notification>(CreateSimpleNotification("id2")));
    763   message_center()->AddNotification(
    764       scoped_ptr<Notification>(CreateSimpleNotification("id3")));
    765   ASSERT_EQ(3u, message_center()->UnreadNotificationCount());
    766 
    767   // Mark 'displayed' on all notifications by using for-loop. This shouldn't
    768   // recreate |notifications| inside of the loop.
    769   const NotificationList::Notifications& notifications =
    770       message_center()->GetVisibleNotifications();
    771   for (NotificationList::Notifications::const_iterator iter =
    772            notifications.begin(); iter != notifications.end(); ++iter) {
    773     message_center()->DisplayedNotification(
    774         (*iter)->id(), message_center::DISPLAY_SOURCE_MESSAGE_CENTER);
    775   }
    776   EXPECT_EQ(0u, message_center()->UnreadNotificationCount());
    777 
    778   // Imitate the timeout, which recovers the unread count. Again, this shouldn't
    779   // recreate |notifications| inside of the loop.
    780   for (NotificationList::Notifications::const_iterator iter =
    781            notifications.begin(); iter != notifications.end(); ++iter) {
    782     message_center()->MarkSinglePopupAsShown((*iter)->id(), false);
    783   }
    784   EXPECT_EQ(3u, message_center()->UnreadNotificationCount());
    785 
    786   // Opening the message center will reset the unread count.
    787   message_center()->SetVisibility(VISIBILITY_MESSAGE_CENTER);
    788   EXPECT_EQ(0u, message_center()->UnreadNotificationCount());
    789 }
    790 
    791 TEST_F(MessageCenterImplTest, DisableNotificationsByNotifier) {
    792   ASSERT_EQ(0u, message_center()->NotificationCount());
    793   message_center()->AddNotification(
    794       scoped_ptr<Notification>(
    795           CreateSimpleNotificationWithNotifierId("id1-1", "app1")));
    796   message_center()->AddNotification(
    797       scoped_ptr<Notification>(
    798           CreateSimpleNotificationWithNotifierId("id1-2", "app1")));
    799   message_center()->AddNotification(
    800       scoped_ptr<Notification>(
    801           CreateSimpleNotificationWithNotifierId("id2-1", "app2")));
    802   message_center()->AddNotification(
    803       scoped_ptr<Notification>(
    804           CreateSimpleNotificationWithNotifierId("id2-2", "app2")));
    805   message_center()->AddNotification(
    806       scoped_ptr<Notification>(
    807           CreateSimpleNotificationWithNotifierId("id2-3", "app2")));
    808   ASSERT_EQ(5u, message_center()->NotificationCount());
    809 
    810   // Removing all of app1's notifications should only leave app2's.
    811   message_center()->DisableNotificationsByNotifier(
    812       NotifierId(NotifierId::APPLICATION, "app1"));
    813   ASSERT_EQ(3u, message_center()->NotificationCount());
    814 
    815   // Now we remove the remaining notifications.
    816   message_center()->DisableNotificationsByNotifier(
    817       NotifierId(NotifierId::APPLICATION, "app2"));
    818   ASSERT_EQ(0u, message_center()->NotificationCount());
    819 }
    820 
    821 TEST_F(MessageCenterImplTest, NotifierEnabledChanged) {
    822   ASSERT_EQ(0u, message_center()->NotificationCount());
    823   message_center()->AddNotification(
    824       scoped_ptr<Notification>(
    825           CreateSimpleNotificationWithNotifierId("id1-1", "app1")));
    826   message_center()->AddNotification(
    827       scoped_ptr<Notification>(
    828           CreateSimpleNotificationWithNotifierId("id1-2", "app1")));
    829   message_center()->AddNotification(
    830       scoped_ptr<Notification>(
    831           CreateSimpleNotificationWithNotifierId("id1-3", "app1")));
    832   message_center()->AddNotification(
    833       scoped_ptr<Notification>(
    834           CreateSimpleNotificationWithNotifierId("id2-1", "app2")));
    835   message_center()->AddNotification(
    836       scoped_ptr<Notification>(
    837           CreateSimpleNotificationWithNotifierId("id2-2", "app2")));
    838   message_center()->AddNotification(
    839       scoped_ptr<Notification>(
    840           CreateSimpleNotificationWithNotifierId("id2-3", "app2")));
    841   message_center()->AddNotification(
    842       scoped_ptr<Notification>(
    843           CreateSimpleNotificationWithNotifierId("id2-4", "app2")));
    844   message_center()->AddNotification(
    845       scoped_ptr<Notification>(
    846           CreateSimpleNotificationWithNotifierId("id2-5", "app2")));
    847   ASSERT_EQ(8u, message_center()->NotificationCount());
    848 
    849   // Enabling an extension should have no effect on the count.
    850   notifier_settings_observer()->NotifierEnabledChanged(
    851       NotifierId(NotifierId::APPLICATION, "app1"), true);
    852   ASSERT_EQ(8u, message_center()->NotificationCount());
    853 
    854   // Removing all of app2's notifications should only leave app1's.
    855   notifier_settings_observer()->NotifierEnabledChanged(
    856       NotifierId(NotifierId::APPLICATION, "app2"), false);
    857   ASSERT_EQ(3u, message_center()->NotificationCount());
    858 
    859   // Removal operations should be idempotent.
    860   notifier_settings_observer()->NotifierEnabledChanged(
    861       NotifierId(NotifierId::APPLICATION, "app2"), false);
    862   ASSERT_EQ(3u, message_center()->NotificationCount());
    863 
    864   // Now we remove the remaining notifications.
    865   notifier_settings_observer()->NotifierEnabledChanged(
    866       NotifierId(NotifierId::APPLICATION, "app1"), false);
    867   ASSERT_EQ(0u, message_center()->NotificationCount());
    868 }
    869 
    870 }  // namespace internal
    871 }  // namespace message_center
    872