Turn on and use the AppInfo data.

chrome/browser/notifications/sync_notifier/synced_notification_unittest.cc

 // 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.
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/notifications/notification.h"
@@ skipping 28 matching lines @@
 
 class SyncedNotificationTest : public testing::Test {
  public:
   SyncedNotificationTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_) {}
   virtual ~SyncedNotificationTest() {}
 
   // Methods from testing::Test.
 
   virtual void SetUp() OVERRIDE {
+    notification_manager_.reset(new StubNotificationUIManager(GURL(
+        kSyncedNotificationsWelcomeOrigin)));
+
     sync_data1_ = CreateSyncData(kTitle1, kText1, kIconUrl1, kImageUrl1,
                                  kAppId1, kKey1, kUnread);
     sync_data2_ = CreateSyncData(kTitle2, kText2, kIconUrl2, kImageUrl2,
                                  kAppId2, kKey2, kUnread);
     // Notification 3 will have the same ID as notification1, but different
     // data inside.
     sync_data3_ = CreateSyncData(kTitle3, kText3, kIconUrl3, kImageUrl3,
                                  kAppId1, kKey1, kUnread);
     // Notification 4 will be the same as 1, but the read state will be 'read'.
     sync_data4_ = CreateSyncData(kTitle1, kText1, kIconUrl1, kImageUrl1,
                                  kAppId1, kKey1, kDismissed);
 
-    notification1_.reset(new SyncedNotification(sync_data1_));
-    notification2_.reset(new SyncedNotification(sync_data2_));
-    notification3_.reset(new SyncedNotification(sync_data3_));
-    notification4_.reset(new SyncedNotification(sync_data4_));
+    notification1_.reset(new SyncedNotification(
+        sync_data1_, NULL, notification_manager_.get()));
+    notification2_.reset(new SyncedNotification(
+        sync_data2_, NULL, notification_manager_.get()));
+    notification3_.reset(new SyncedNotification(
+        sync_data3_, NULL, notification_manager_.get()));
+    notification4_.reset(new SyncedNotification(
+        sync_data4_, NULL, notification_manager_.get()));
 
-    notification_manager_.reset(new StubNotificationUIManager(GURL(
-        kSyncedNotificationsWelcomeOrigin)));
   }
 
   virtual void TearDown() OVERRIDE {
     notification_manager_.reset();
   }
 
   virtual void AddButtonBitmaps(SyncedNotification* notification,
                                 unsigned int how_many) {
     for (unsigned int i = 0; i < how_many; ++i) {
       notification->button_bitmaps_.push_back(gfx::Image());
@@ skipping 68 matching lines @@
 
 // TODO(petewil): Improve ctor to pass in an image and type so this test can
 // pass on actual data.
 TEST_F(SyncedNotificationTest, GetImageURLTest) {
   GURL found_image_url = notification1_->GetImageUrl();
   GURL expected_image_url = GURL(kImageUrl1);
 
   EXPECT_EQ(expected_image_url, found_image_url);
 }
 
-// TODO(petewil): test with a multi-line message
 TEST_F(SyncedNotificationTest, GetTextTest) {
   std::string found_text = notification1_->GetText();
   std::string expected_text(kText1);
 
   EXPECT_EQ(expected_text, found_text);
 }
 
 TEST_F(SyncedNotificationTest, GetCreationTimeTest) {
   uint64 found_time = notification1_->GetCreationTime();
   EXPECT_EQ(kFakeCreationTime, found_time);
@@ skipping 68 matching lines @@
 TEST_F(SyncedNotificationTest, EqualsIgnoringReadStateTest) {
   EXPECT_TRUE(notification1_->EqualsIgnoringReadState(*notification1_));
   EXPECT_TRUE(notification2_->EqualsIgnoringReadState(*notification2_));
   EXPECT_FALSE(notification1_->EqualsIgnoringReadState(*notification2_));
   EXPECT_FALSE(notification1_->EqualsIgnoringReadState(*notification3_));
   EXPECT_TRUE(notification1_->EqualsIgnoringReadState(*notification4_));
 }
 
 TEST_F(SyncedNotificationTest, UpdateTest) {
   scoped_ptr<SyncedNotification> notification5;
-  notification5.reset(new SyncedNotification(sync_data1_));
+  notification5.reset(new SyncedNotification(
+      sync_data1_, NULL, notification_manager()));
 
   // update with the sync data from notification2, and ensure they are equal.
   notification5->Update(sync_data2_);
   EXPECT_TRUE(notification5->EqualsIgnoringReadState(*notification2_));
   EXPECT_EQ(notification5->GetReadState(), notification2_->GetReadState());
   EXPECT_FALSE(notification5->EqualsIgnoringReadState(*notification1_));
 }
 
 TEST_F(SyncedNotificationTest, ShowTest) {
 
   if (!UseRichNotifications())
     return;
 
   // Call the method under test using the pre-populated data.
-  notification1_->Show(notification_manager(), NULL, NULL);
+  notification1_->Show(NULL);
 
   const Notification notification = notification_manager()->notification();
 
   // Check the base fields of the notification.
   EXPECT_EQ(message_center::NOTIFICATION_TYPE_IMAGE, notification.type());
   EXPECT_EQ(std::string(kTitle1), base::UTF16ToUTF8(notification.title()));
   EXPECT_EQ(std::string(kText1), base::UTF16ToUTF8(notification.message()));
   EXPECT_EQ(std::string(kExpectedOriginUrl), notification.origin_url().spec());
   EXPECT_EQ(std::string(kKey1), base::UTF16ToUTF8(notification.replace_id()));
 
   EXPECT_EQ(kFakeCreationTime, notification.timestamp().ToDoubleT());
   EXPECT_EQ(kNotificationPriority, notification.priority());
 }
 
 TEST_F(SyncedNotificationTest, DismissTest) {
 
   if (!UseRichNotifications())
     return;
 
   // Call the method under test using a dismissed notification.
-  notification4_->Show(notification_manager(), NULL, NULL);
+  notification4_->Show(NULL);
 
   EXPECT_EQ(std::string(kKey1), notification_manager()->dismissed_id());
 }
 
-TEST_F(SyncedNotificationTest, AddBitmapToFetchQueueTest) {
+TEST_F(SyncedNotificationTest, CreateBitmapFetcherTest) {
   scoped_ptr<SyncedNotification> notification6;
-  notification6.reset(new SyncedNotification(sync_data1_));
+  notification6.reset(new SyncedNotification(
+      sync_data1_, NULL, notification_manager()));
 
   // Add two bitmaps to the queue.
-  notification6->AddBitmapToFetchQueue(GURL(kIconUrl1));
-  notification6->AddBitmapToFetchQueue(GURL(kIconUrl2));
+  notification6->CreateBitmapFetcher(GURL(kIconUrl1));
+  notification6->CreateBitmapFetcher(GURL(kIconUrl2));
 
   EXPECT_EQ(GURL(kIconUrl1), notification6->fetchers_[0]->url());
   EXPECT_EQ(GURL(kIconUrl2), notification6->fetchers_[1]->url());
 
-  notification6->AddBitmapToFetchQueue(GURL(kIconUrl2));
+  notification6->CreateBitmapFetcher(GURL(kIconUrl2));
 }
 
 TEST_F(SyncedNotificationTest, OnFetchCompleteTest) {
   if (!UseRichNotifications())
     return;
 
   // Set up the internal state that FetchBitmaps() would have set.
   notification1_->notification_manager_ = notification_manager();
 
   // Add the bitmaps to the queue for us to match up.
-  notification1_->AddBitmapToFetchQueue(GURL(kIconUrl1));
-  notification1_->AddBitmapToFetchQueue(GURL(kImageUrl1));
-  notification1_->AddBitmapToFetchQueue(GURL(kButtonOneIconUrl));
-  notification1_->AddBitmapToFetchQueue(GURL(kButtonTwoIconUrl));
+  notification1_->CreateBitmapFetcher(GURL(kIconUrl1));
+  notification1_->CreateBitmapFetcher(GURL(kImageUrl1));
+  notification1_->CreateBitmapFetcher(GURL(kButtonOneIconUrl));
+  notification1_->CreateBitmapFetcher(GURL(kButtonTwoIconUrl));
 
   // Put some realistic looking bitmap data into the url_fetcher.
   SkBitmap bitmap;
 
   // Put a real bitmap into "bitmap".  2x2 bitmap of green 32 bit pixels.
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, 2, 2);
   bitmap.allocPixels();
   bitmap.eraseColor(SK_ColorGREEN);
 
   // Allocate the button_bitmaps_ array as the calling function normally would.
@@ skipping 20 matching lines @@
   EXPECT_EQ(
       std::string(kText1),
       base::UTF16ToUTF8(notification_manager()->notification().message()));
 
   // TODO(petewil): Check that the bitmap in the notification is what we expect.
   // This fails today, the type info is different.
   // EXPECT_TRUE(gfx::BitmapsAreEqual(
   //     image, notification1_->GetAppIconBitmap()));
 }
 
-
+// TODO(petewil): Empty bitmap should count as a successful fetch.
 TEST_F(SyncedNotificationTest, EmptyBitmapTest) {
   if (!UseRichNotifications())
     return;
 
   // Set up the internal state that FetchBitmaps() would have set.
   notification1_->notification_manager_ = notification_manager();
 
   // Add the bitmaps to the queue for us to match up.
-  notification1_->AddBitmapToFetchQueue(GURL(kIconUrl1));
-  notification1_->AddBitmapToFetchQueue(GURL(kImageUrl1));
-  notification1_->AddBitmapToFetchQueue(GURL(kButtonOneIconUrl));
-  notification1_->AddBitmapToFetchQueue(GURL(kButtonTwoIconUrl));
+  notification1_->CreateBitmapFetcher(GURL(kIconUrl1));
+  notification1_->CreateBitmapFetcher(GURL(kImageUrl1));
+  notification1_->CreateBitmapFetcher(GURL(kButtonOneIconUrl));
+  notification1_->CreateBitmapFetcher(GURL(kButtonTwoIconUrl));
 
   // Put some realistic looking bitmap data into the url_fetcher.
   SkBitmap bitmap;
   SkBitmap empty_bitmap;
 
   // Put a real bitmap into "bitmap".  2x2 bitmap of green 32 bit pixels.
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, 2, 2);
   bitmap.allocPixels();
   bitmap.eraseColor(SK_ColorGREEN);
 
@@ skipping 17 matching lines @@
   // Since we check Show() thoroughly in its own test, we only check cursorily.
   EXPECT_EQ(message_center::NOTIFICATION_TYPE_IMAGE,
             notification_manager()->notification().type());
   EXPECT_EQ(std::string(kTitle1),
             base::UTF16ToUTF8(notification_manager()->notification().title()));
   EXPECT_EQ(
       std::string(kText1),
       base::UTF16ToUTF8(notification_manager()->notification().message()));
 }
 
+TEST_F(SyncedNotificationTest, ShowIfNewlyEnabledTest) {
+  if (!UseRichNotifications())
+    return;
+
+  // Call the method using the wrong app id, nothing should get shown.
+  notification1_->ShowAllForAppId(NULL, kAppId2);
+
+  // Ensure no notification was generated and shown.
+  const Notification notification1 = notification_manager()->notification();
+  EXPECT_EQ(std::string(), base::UTF16ToUTF8(notification1.replace_id()));
+
+  // Call the method under test using the pre-populated data.
+  notification1_->ShowAllForAppId(NULL, kAppId1);
+
+  const Notification notification2 = notification_manager()->notification();
+
+  // Check the base fields of the notification.
+  EXPECT_EQ(message_center::NOTIFICATION_TYPE_IMAGE, notification2.type());
+  EXPECT_EQ(std::string(kTitle1), base::UTF16ToUTF8(notification2.title()));
+  EXPECT_EQ(std::string(kText1), base::UTF16ToUTF8(notification2.message()));
+  EXPECT_EQ(std::string(kExpectedOriginUrl), notification2.origin_url().spec());
+  EXPECT_EQ(std::string(kKey1), base::UTF16ToUTF8(notification2.replace_id()));
+
+  EXPECT_EQ(kFakeCreationTime, notification2.timestamp().ToDoubleT());
+  EXPECT_EQ(kNotificationPriority, notification2.priority());
+}
+
+TEST_F(SyncedNotificationTest, HideIfNewlyRemovedTest) {
+  if (!UseRichNotifications())
+    return;
+
+  // Add the notification to the notification manger, so it exists before we
+  // we remove it.
+  notification1_->Show(NULL);
+  const Notification* found1 = notification_manager()->FindById(kKey1);
+  EXPECT_NE(reinterpret_cast<Notification*>(NULL), found1);
+
+  // Call the method under test using the pre-populated data.
+  notification1_->HideAllForAppId(kAppId1);
+
+  // Ensure the notification was removed from the notification manager
+  EXPECT_EQ(std::string(kKey1), notification_manager()->dismissed_id());
+}
+
 // TODO(petewil): Add a test for a notification being read and or deleted.
 
 }  // namespace notifier