Limit number of notifications that can be received by the client.

chrome/browser/extensions/app_notification_manager_sync_unittest.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "chrome/browser/extensions/app_notification.h"
 #include "chrome/browser/extensions/app_notification_manager.h"
 #include "chrome/browser/sync/protocol/app_notification_specifics.pb.h"
@@ skipping 94 matching lines @@
   AppNotificationManager* model() { return model_.get(); }
   TestChangeProcessor* processor() { return &processor_; }
 
   // Creates a notification whose properties are set from the given integer.
   static AppNotification* CreateNotification(int suffix) {
     return CreateNotification(false, suffix);
   }
   static AppNotification* CreateNotification(bool is_local, int suffix) {
     std::string s = base::IntToString(suffix);
     return CreateNotification(
-        is_local, "guid" + s, "ext" + s, "text" + s, "body" + s,
+        is_local, suffix, "guid" + s, "ext" + s, "text" + s, "body" + s,
         "http://www.url" + s + ".com", "link text " + s);
   }
   static AppNotification* CreateNotification(
       bool is_local, int suffix, const std::string& extension_id) {
     std::string s = base::IntToString(suffix);
     return CreateNotification(
-        is_local, "guid" + s, extension_id, "text" + s, "body" + s,
+        is_local, suffix, "guid" + s, extension_id, "text" + s, "body" + s,
         "http://www.url" + s + ".com", "link text " + s);
   }
 
   // Creates a notification whose properties are set from the given integer
   // but does not set link url and link text.
   static AppNotification* CreateNotificationNoLink(int suffix) {
     return CreateNotificationNoLink(false, suffix);
   }
   static AppNotification* CreateNotificationNoLink(bool is_local, int suffix) {
     std::string s = base::IntToString(suffix);
     return CreateNotification(
-        is_local, "guid" + s, "ext" + s, "text" + s, "body" + s, "", "");
+        is_local, suffix,
+        "guid" + s, "ext" + s, "text" + s, "body" + s, "", "");
   }
 
   // link_url and link_text are only set if the passed in values are not empty.
   static AppNotification* CreateNotification(bool is_local,
+                                             double time,
                                              const std::string& guid,
                                              const std::string& extension_id,
                                              const std::string& title,
                                              const std::string& body,
                                              const std::string& link_url,
                                              const std::string& link_text) {
     AppNotification* notif = new AppNotification(
-        is_local, guid, extension_id, title, body);
+        is_local, time, guid, extension_id, title, body);
     if (!link_url.empty())
       notif->set_link_url(GURL(link_url));
     if (!link_text.empty())
       notif->set_link_text(link_text);
     return notif;
   }
 
   static SyncData CreateSyncData(int suffix) {
     scoped_ptr<AppNotification> notif(CreateNotification(suffix));
     return AppNotificationManager::CreateSyncDataFromNotification(*notif);
@@ skipping 248 matching lines @@
 // should be returned.
 TEST_F(AppNotificationManagerSyncTest, ModelAssocBothNonEmptyTitleMismatch) {
   AppNotification* n1 = CreateNotification(1);
   model()->Add(n1);
   AppNotification* n2 = CreateNotification(true, 2);
   model()->Add(n2);
 
   SyncDataList initial_data;
   initial_data.push_back(CreateSyncData(1));
   scoped_ptr<AppNotification> n1_a(CreateNotification(
-      n1->is_local(), n1->guid(), n1->extension_id(),
+      n1->is_local(), n1->creation_timestamp_ms(),
+      n1->guid(), n1->extension_id(),
       n1->title() + "_changed", // different title
       n1->body(), n1->link_url().spec(), n1->link_text()));
   initial_data.push_back(
       AppNotificationManager::CreateSyncDataFromNotification(*n1_a));
 
   SyncError sync_error = model()->MergeDataAndStartSyncing(
       syncable::APP_NOTIFICATIONS,
       initial_data,
       processor());
 
@@ skipping 67 matching lines @@
   changes.push_back(CreateSyncChange(SyncChange::ACTION_DELETE, n1->Copy()));
   changes.push_back(CreateSyncChange(
       SyncChange::ACTION_ADD, CreateNotification(4)));
 
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
   EXPECT_EQ(2, processor()->change_list_size());
 }
 
+// Process over 15 changes changes when model is not empty.
+TEST_F(AppNotificationManagerSyncTest, ProcessSyncChangesEmptyModelWithMax) {
+  const std::string& ext_id = "e1";
+  model()->MergeDataAndStartSyncing(
+      syncable::APP_NOTIFICATIONS,
+      SyncDataList(),
+      processor());
+  for (unsigned int i = 0;
+       i < notification_manager_constants::kMaxNotificationPerApp * 2; i++) {
+    SyncChangeList changes;
+    changes.push_back(CreateSyncChange(
+      SyncChange::ACTION_ADD, CreateNotification(false, i, ext_id)));
+    model()->ProcessSyncChanges(FROM_HERE, changes);
+    if (i < notification_manager_constants::kMaxNotificationPerApp) {
+      EXPECT_EQ(i + 1,
+                model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
+    } else {
+      EXPECT_EQ(notification_manager_constants::kMaxNotificationPerApp,
+        model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
+      for (unsigned int j = i; j > i - 5; j--) {
+        EXPECT_EQ(
+            notification_manager_constants::kMaxNotificationPerApp,
+            model()->GetAllSyncData(syncable::APP_NOTIFICATIONS).size());
+      }
+    }
+  }
+}
+
 // Process sync changes should return error if model association is not done.
 TEST_F(AppNotificationManagerSyncTest,
        ProcessSyncChangesErrorModelAssocNotDone) {
   SyncChangeList changes;
 
   SyncError sync_error = model()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_TRUE(sync_error.IsSet());
   EXPECT_EQ(syncable::APP_NOTIFICATIONS, sync_error.type());
   EXPECT_EQ(0, processor()->change_list_size());
 }
@@ skipping 64 matching lines @@
 
   EXPECT_EQ(3, processor()->change_list_size());
   EXPECT_TRUE(processor()->ContainsGuid(n1->guid()));
   SyncChange c1 = processor()->GetChangeByGuid(n1->guid());
   AssertSyncChange(c1, SyncChange::ACTION_DELETE, *n1);
   SyncChange c2 = processor()->GetChangeByGuid(n2->guid());
   AssertSyncChange(c2, SyncChange::ACTION_DELETE, *n2);
   SyncChange c3 = processor()->GetChangeByGuid(n3->guid());
   AssertSyncChange(c3, SyncChange::ACTION_DELETE, *n3);
 }